import type { KnowledgeDetail } from '@/types/knowledge';

/**
 * 基础语法知识点数据
 */
export const basicKnowledge : KnowledgeDetail[] = [
	{
		id: 1,
		title: '变量与数据类型',
		description: 'Java是强类型语言，掌握8种基本数据类型和引用类型的使用是Java编程的基础。',
		icon: '💾',
		categoryId: 'basic',
		categoryName: 'Java基础语法',
		categoryIcon: '📝',
		difficulty: '入门',
		color: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
		headerBg: 'linear-gradient(135deg, #2c3e50 0%, #34495e 100%)',
		tagBg: 'linear-gradient(135deg, #3498db 0%, #2980b9 100%)',
		tagColor: '#ffffff',
		difficultyBg: 'linear-gradient(135deg, #2ecc71 0%, #27ae60 100%)',
		keyPoints: [
			{
				point: '8种基本数据类型：byte、short、int、long、float、double、char、boolean，每种类型都有固定的内存大小和取值范围。',
				code: `// 整数类型
byte byteVar = 127;           // 8位，范围：-128 ~ 127
short shortVar = 32767;       // 16位，范围：-32768 ~ 32767
int intVar = 2147483647;      // 32位，范围：-2^31 ~ 2^31-1
long longVar = 9223372036854775807L; // 64位，需要加L后缀

// 浮点类型
float floatVar = 3.14f;       // 32位，需要加f后缀
double doubleVar = 3.14159;   // 64位，默认类型

// 字符和布尔类型
char charVar = 'A';           // 16位Unicode字符
boolean boolVar = true;       // true或false`
			},
			{
				point: '引用数据类型包括类、接口、数组。引用类型存储的是对象的内存地址，而不是实际数据。',
				code: `// 字符串类型（类）
String name = "Java";
String greeting = new String("Hello");

// 数组类型
int[] numbers = {1, 2, 3, 4, 5};
String[] names = new String[3];
names[0] = "Alice";

// 对象类型
Person person = new Person();
List<String> list = new ArrayList<>();`
			},
			{
				point: '变量命名遵循驼峰命名法，类名首字母大写（PascalCase），变量和方法名首字母小写（camelCase）。',
				code: `// 类名：大驼峰（PascalCase）
public class UserAccount {
    
    // 常量：全大写，单词间用下划线分隔
    public static final int MAX_USER_COUNT = 1000;
    
    // 成员变量：小驼峰（camelCase）
    private String userName;
    private int userAge;
    
    // 方法名：小驼峰
    public void getUserInfo() {
        // 局部变量：小驼峰
        int totalCount = 0;
        String firstName = "John";
    }
}`
			},
			{
				point: '类型转换分为自动类型转换（小范围到大范围）和强制类型转换（大范围到小范围，可能丢失精度）。',
				code: `// 自动类型转换（隐式转换）
int intValue = 100;
long longValue = intValue;        // int自动转为long
double doubleValue = intValue;    // int自动转为double

// 强制类型转换（显式转换）
double d = 99.99;
int i = (int) d;                  // 结果为99，小数部分被截断
long l = 1000L;
int j = (int) l;                  // 可能会溢出

// 包装类型转换
Integer intObj = 100;             // 自动装箱
int intPrimitive = intObj;        // 自动拆箱`
			},
			{
				point: '使用final关键字定义常量，常量一旦赋值后不能修改，常量名通常使用全大写字母。',
				code: `public class Constants {
    // 编译时常量
    public static final double PI = 3.14159;
    public static final String APP_NAME = "MyApp";
    public static final int MAX_SIZE = 100;
    
    // 运行时常量
    public static final long CURRENT_TIME = System.currentTimeMillis();
    
    public void example() {
        // 局部常量
        final int MAX_RETRY = 3;
        final String ERROR_MSG = "操作失败";
        
        // MAX_RETRY = 5;  // 编译错误：无法修改final变量
    }
}`
			}
		]
	},
	{
		id: 2,
		title: '运算符',
		description: 'Java提供了丰富的运算符，包括算术、关系、逻辑、位运算等，掌握运算符优先级和使用场景。',
		icon: '➕',
		categoryId: 'basic',
		categoryName: 'Java基础语法',
		categoryIcon: '📝',
		difficulty: '入门',
		color: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
		headerBg: 'linear-gradient(135deg, #2c3e50 0%, #34495e 100%)',
		tagBg: 'linear-gradient(135deg, #3498db 0%, #2980b9 100%)',
		tagColor: '#ffffff',
		difficultyBg: 'linear-gradient(135deg, #2ecc71 0%, #27ae60 100%)',
		keyPoints: [
			{
				point: '算术运算符包括加(+)、减(-)、乘(*)、除(/)、取模(%)、自增(++)、自减(--)，注意整数除法会截断小数部分。',
				code: `// 基本算术运算
int a = 10, b = 3;
int sum = a + b;        // 13
int diff = a - b;       // 7
int product = a * b;    // 30
int quotient = a / b;   // 3（整数除法）
int remainder = a % b;  // 1（取模）

// 浮点除法
double result = (double) a / b;  // 3.3333...

// 自增自减
int x = 5;
int y = x++;  // y=5, x=6（后自增）
int z = ++x;  // z=7, x=7（前自增）`
			},
			{
				point: '关系运算符用于比较两个值，返回boolean结果，包括==、!=、>、<、>=、<=。',
				code: `int a = 10, b = 20;

// 关系运算符
boolean isEqual = (a == b);       // false
boolean notEqual = (a != b);      // true
boolean greater = (a > b);        // false
boolean less = (a < b);           // true
boolean greaterOrEqual = (a >= 10); // true

// 对象比较
String s1 = "Hello";
String s2 = "Hello";
String s3 = new String("Hello");

boolean b1 = (s1 == s2);          // true（字符串常量池）
boolean b2 = (s1 == s3);          // false（不同对象）
boolean b3 = s1.equals(s3);       // true（内容相同）`
			},
			{
				point: '逻辑运算符用于组合多个条件，包括与(&&)、或(||)、非(!)，支持短路求值。',
				code: `int age = 25;
boolean hasLicense = true;

// 逻辑与（&&）：所有条件都为true才返回true
boolean canDrive = (age >= 18) && hasLicense;  // true

// 逻辑或（||）：任一条件为true就返回true
boolean isAdult = (age >= 18) || (age < 0);    // true

// 逻辑非（!）：取反
boolean isMinor = !(age >= 18);                // false

// 短路求值
int x = 0;
boolean result = (x != 0) && (10 / x > 1);     // false，不会执行除法
// boolean error = (x == 0) & (10 / x > 1);    // 会抛出ArithmeticException`
			},
			{
				point: '位运算符直接操作二进制位，包括按位与(&)、或(|)、异或(^)、取反(~)、左移(<<)、右移(>>)。',
				code: `int a = 60;  // 0011 1100
int b = 13;  // 0000 1101

// 按位与：都为1才为1
int and = a & b;   // 0000 1100 = 12

// 按位或：有1就为1
int or = a | b;    // 0011 1101 = 61

// 按位异或：不同为1
int xor = a ^ b;   // 0011 0001 = 49

// 按位取反
int not = ~a;      // 1100 0011 = -61

// 左移：相当于乘以2
int left = a << 2; // 1111 0000 = 240

// 右移：相当于除以2
int right = a >> 2; // 0000 1111 = 15`
			},
			{
				point: '三元运算符(? :)提供简洁的条件表达式，格式为：条件 ? 值1 : 值2。',
				code: `// 基本用法
int a = 10, b = 20;
int max = (a > b) ? a : b;        // 20

// 嵌套三元运算符
int x = 5;
String result = (x > 0) ? "正数" : 
                (x < 0) ? "负数" : "零";

// 替代if-else
int age = 18;
String status = (age >= 18) ? "成年人" : "未成年人";

// 等价的if-else
String status2;
if (age >= 18) {
    status2 = "成年人";
} else {
    status2 = "未成年人";
}`
			}
		]
	},
	{
		id: 3,
		title: '流程控制',
		description: '流程控制语句决定程序的执行路径，包括条件语句(if、switch)和循环语句(for、while、do-while)。',
		icon: '🔀',
		categoryId: 'basic',
		categoryName: 'Java基础语法',
		categoryIcon: '📝',
		difficulty: '入门',
		color: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
		headerBg: 'linear-gradient(135deg, #2c3e50 0%, #34495e 100%)',
		tagBg: 'linear-gradient(135deg, #3498db 0%, #2980b9 100%)',
		tagColor: '#ffffff',
		difficultyBg: 'linear-gradient(135deg, #2ecc71 0%, #27ae60 100%)',
		keyPoints: [
			{
				point: 'if-else语句根据条件执行不同代码块，可以嵌套使用，注意代码块作用域。',
				code: `// 单分支
int score = 85;
if (score >= 60) {
    System.out.println("及格");
}

// 双分支
if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

// 多分支
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}`
			},
			{
				point: 'switch语句适用于多个固定值的判断，支持int、char、String、枚举类型，注意break的使用。',
				code: `// 基本用法
int day = 3;
switch (day) {
    case 1:
        System.out.println("星期一");
        break;
    case 2:
        System.out.println("星期二");
        break;
    case 3:
        System.out.println("星期三");
        break;
    default:
        System.out.println("其他");
}

// 字符串switch（Java 7+）
String fruit = "apple";
switch (fruit) {
    case "apple":
        System.out.println("苹果");
        break;
    case "banana":
        System.out.println("香蕉");
        break;
}

// 贯穿效果（省略break）
int month = 2;
switch (month) {
    case 12:
    case 1:
    case 2:
        System.out.println("冬季");
        break;
}`
			},
			{
				point: 'for循环适用于明确循环次数的场景，增强for循环用于遍历数组和集合。',
				code: `// 基本for循环
for (int i = 0; i < 5; i++) {
    System.out.println("第" + i + "次循环");
}

// 增强for循环（for-each）
int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
    System.out.println(num);
}

// 嵌套循环
for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        System.out.print(i + "," + j + " ");
    }
    System.out.println();
}

// 无限循环
for (;;) {
    // 需要break跳出
}`
			},
			{
				point: 'while循环先判断条件再执行，do-while循环先执行再判断（至少执行一次）。',
				code: `// while循环
int i = 0;
while (i < 5) {
    System.out.println(i);
    i++;
}

// do-while循环（至少执行一次）
int j = 0;
do {
    System.out.println(j);
    j++;
} while (j < 5);

// 区别示例
int x = 10;
while (x < 5) {
    System.out.println("不会执行");
}

do {
    System.out.println("至少执行一次");
} while (x < 5);`
			},
			{
				point: 'break跳出当前循环，continue跳过本次循环，return结束方法执行，标签可用于跳出多层循环。',
				code: `// break：跳出循环
for (int i = 0; i < 10; i++) {
    if (i == 5) break;
    System.out.println(i);  // 输出0-4
}

// continue：跳过本次循环
for (int i = 0; i < 5; i++) {
    if (i == 2) continue;
    System.out.println(i);  // 输出0,1,3,4
}

// 标签：跳出多层循环
outer: for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (i == 1 && j == 1) {
            break outer;  // 跳出外层循环
        }
        System.out.println(i + "," + j);
    }
}`
			}
		]
	},
	{
		id: 4,
		title: '数组',
		description: '数组是存储相同类型数据的固定大小容器，理解数组的声明、初始化、访问和常用操作。',
		icon: '📊',
		categoryId: 'basic',
		categoryName: 'Java基础语法',
		categoryIcon: '📝',
		difficulty: '入门',
		color: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
		headerBg: 'linear-gradient(135deg, #2c3e50 0%, #34495e 100%)',
		tagBg: 'linear-gradient(135deg, #3498db 0%, #2980b9 100%)',
		tagColor: '#ffffff',
		difficultyBg: 'linear-gradient(135deg, #2ecc71 0%, #27ae60 100%)',
		keyPoints: [
			{
				point: '数组声明和初始化有多种方式，数组长度固定且不可改变，访问越界会抛出ArrayIndexOutOfBoundsException。',
				code: `// 声明并初始化
int[] numbers1 = {1, 2, 3, 4, 5};
int[] numbers2 = new int[]{1, 2, 3, 4, 5};

// 先声明后初始化
int[] numbers3 = new int[5];  // 默认值为0
numbers3[0] = 1;
numbers3[1] = 2;

// 多种声明方式
int[] arr1;  // 推荐
int arr2[];  // 不推荐

// 获取数组长度
int length = numbers1.length;  // 5

// 数组越界
// int x = numbers1[10];  // ArrayIndexOutOfBoundsException`
			},
			{
				point: '多维数组本质是数组的数组，最常用的是二维数组，可以表示表格、矩阵等数据结构。',
				code: `// 二维数组声明和初始化
int[][] matrix1 = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// 先声明后赋值
int[][] matrix2 = new int[3][3];
matrix2[0][0] = 1;
matrix2[1][1] = 5;

// 不规则数组
int[][] irregular = new int[3][];
irregular[0] = new int[2];
irregular[1] = new int[3];
irregular[2] = new int[4];

// 遍历二维数组
for (int i = 0; i < matrix1.length; i++) {
    for (int j = 0; j < matrix1[i].length; j++) {
        System.out.print(matrix1[i][j] + " ");
    }
    System.out.println();
}`
			},
			{
				point: '数组遍历可以使用普通for循环（可修改元素）或增强for循环（只读访问）。',
				code: `int[] numbers = {1, 2, 3, 4, 5};

// 普通for循环（可以修改元素）
for (int i = 0; i < numbers.length; i++) {
    numbers[i] = numbers[i] * 2;  // 可以修改
    System.out.println(numbers[i]);
}

// 增强for循环（for-each）
for (int num : numbers) {
    System.out.println(num);
    // num = num * 2;  // 不会修改原数组
}

// 倒序遍历
for (int i = numbers.length - 1; i >= 0; i--) {
    System.out.println(numbers[i]);
}`
			},
			{
				point: 'Arrays工具类提供了丰富的数组操作方法，如排序、查找、填充、比较、转换等。',
				code: `import java.util.Arrays;

int[] numbers = {5, 2, 8, 1, 9};

// 排序
Arrays.sort(numbers);  // [1, 2, 5, 8, 9]

// 二分查找（数组必须已排序）
int index = Arrays.binarySearch(numbers, 5);  // 2

// 填充
int[] arr = new int[5];
Arrays.fill(arr, 10);  // [10, 10, 10, 10, 10]

// 数组复制
int[] copy = Arrays.copyOf(numbers, numbers.length);

// 数组比较
boolean isEqual = Arrays.equals(numbers, copy);

// 转换为字符串
String str = Arrays.toString(numbers);  // "[1, 2, 5, 8, 9]"`
			},
			{
				point: '数组复制有多种方式，包括Arrays.copyOf()、System.arraycopy()、clone()方法，注意浅拷贝和深拷贝的区别。',
				code: `int[] original = {1, 2, 3, 4, 5};

// 方式1：Arrays.copyOf()
int[] copy1 = Arrays.copyOf(original, original.length);

// 方式2：System.arraycopy()
int[] copy2 = new int[5];
System.arraycopy(original, 0, copy2, 0, original.length);

// 方式3：clone()
int[] copy3 = original.clone();

// 方式4：手动复制
int[] copy4 = new int[original.length];
for (int i = 0; i < original.length; i++) {
    copy4[i] = original[i];
}

// 注意：对象数组的浅拷贝
String[] names = {"Alice", "Bob"};
String[] namesCopy = names.clone();  // 浅拷贝
namesCopy[0] = "Charlie";  // 不影响原数组`
			}
		]
	},
	{
		id: 5,
		title: '方法',
		description: '方法是Java中最基本的代码组织单元，理解方法定义、调用、参数传递、返回值和重载。',
		icon: '⚙️',
		categoryId: 'basic',
		categoryName: 'Java基础语法',
		categoryIcon: '📝',
		difficulty: '入门',
		color: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
		headerBg: 'linear-gradient(135deg, #2c3e50 0%, #34495e 100%)',
		tagBg: 'linear-gradient(135deg, #3498db 0%, #2980b9 100%)',
		tagColor: '#ffffff',
		difficultyBg: 'linear-gradient(135deg, #2ecc71 0%, #27ae60 100%)',
		keyPoints: [
			{
				point: '方法由访问修饰符、返回类型、方法名、参数列表和方法体组成，遵循单一职责原则。',
				code: `public class Calculator {
    // 有返回值、有参数
    public int add(int a, int b) {
        return a + b;
    }
    
    // 无返回值、有参数
    public void printSum(int a, int b) {
        System.out.println("和为：" + (a + b));
    }
    
    // 有返回值、无参数
    public String getMessage() {
        return "Hello World";
    }
    
    // 无返回值、无参数
    public void sayHello() {
        System.out.println("Hello");
    }
}`
			},
			{
				point: 'Java是值传递，基本类型传递的是值的副本，引用类型传递的是引用的副本（地址）。',
				code: `public class ParameterTest {
    // 基本类型参数
    public void changeInt(int x) {
        x = 100;  // 不影响外部变量
    }
    
    // 引用类型参数
    public void changeArray(int[] arr) {
        arr[0] = 100;  // 会影响原数组
    }
    
    public void changeString(String str) {
        str = "new";  // 不影响原字符串（String不可变）
    }
    
    public static void main(String[] args) {
        int num = 10;
        changeInt(num);
        System.out.println(num);  // 10
        
        int[] array = {1, 2, 3};
        changeArray(array);
        System.out.println(array[0]);  // 100
    }
}`
			},
			{
				point: '方法重载允许同名方法有不同的参数列表（参数个数、类型或顺序不同），返回类型不影响重载。',
				code: `public class OverloadDemo {
    // 参数个数不同
    public int add(int a, int b) {
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    
    // 参数类型不同
    public double add(double a, double b) {
        return a + b;
    }
    
    // 参数顺序不同
    public void print(int num, String text) {
        System.out.println(num + ": " + text);
    }
    
    public void print(String text, int num) {
        System.out.println(text + ": " + num);
    }
}`
			},
			{
				point: '可变参数(varargs)允许方法接受不定数量的参数，本质是数组，必须是参数列表的最后一个。',
				code: `public class VarargsDemo {
    // 可变参数
    public int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
    
    // 调用方式
    public void test() {
        sum(1, 2);              // 2个参数
        sum(1, 2, 3, 4);        // 4个参数
        sum();                  // 0个参数
        
        int[] arr = {1, 2, 3};
        sum(arr);               // 传递数组
    }
    
    // 可变参数必须是最后一个参数
    public void print(String prefix, int... numbers) {
        System.out.print(prefix + ": ");
        for (int num : numbers) {
            System.out.print(num + " ");
        }
    }
}`
			},
			{
				point: '递归方法是调用自身的方法，必须有终止条件，适用于树形结构、分治算法等场景。',
				code: `public class RecursionDemo {
    // 阶乘
    public int factorial(int n) {
        if (n <= 1) {  // 终止条件
            return 1;
        }
        return n * factorial(n - 1);  // 递归调用
    }
    
    // 斐波那契数列
    public int fibonacci(int n) {
        if (n <= 1) {
            return n;
        }
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
    
    // 遍历目录（实际应用）
    public void listFiles(File dir, int depth) {
        if (!dir.isDirectory()) return;
        
        File[] files = dir.listFiles();
        for (File file : files) {
            System.out.println("  ".repeat(depth) + file.getName());
            if (file.isDirectory()) {
                listFiles(file, depth + 1);  // 递归
            }
        }
    }
}`
			}
		]
	}
];